// // 格式化代码shift+alt+f

// //构造函数和析构函数
// #include <iostream>
// using  namespace std;
// class String{
//     private:
//     int *data;
//     public:
//     String(int size)
//     {
//         data=new int[size];
//         cout<<"构造函数被调用，分配了内存"<<endl;
//     }
//     ~String()
//     {
//         delete[] data;
//         cout<<"析构函数被调用，释放了内存"<<endl;

//     }
// };
// int main()
// {
//     String s1(2);
//     int a=0;
//     cout<<"请输入"<<endl;
//     cin>>a;
//     cout<<"end"<<a<<endl;
//     return 0;
// }

// //运算符重载
// #include <iostream>
// using namespace std;
// class Vector2D{
//     private :
//     double x,y;
//     public:
//     Vector2D (double x=0,double y=0);//声明构造函数
//     Vector2D operator+(const Vector2D&other)const;//const保证函数不会修改对象状态
//      friend ostream& operator<<(ostream& os, const Vector2D& v) {
//         os << "(" << v.x << ", " << v.y << ")";
//         return os;
//     }
// };
// Vector2D::Vector2D(double x,double y):x(x),y(y){
// };//构造函数实现直接初始化版在（构造前）
//    Vector2D Vector2D::operator+(const Vector2D&other)const{
//         return Vector2D(x+other.x,y+other.y);
//     }
// int main()
// {
//     Vector2D v1(3.0, 4.0);
//     Vector2D v2(1.0, 2.0);
//     // 使用重载的运算符
//     Vector2D sum = v1 + v2;
//     cout << "v1 = " << v1 << endl;
//     cout << "v2 = " << v2 << endl;
//     cout << "v1 + v2 = " << sum << endl;
//     return 0;
// }

// //内存管理
// #include <memory>
// #include <iostream>
// using namespace std;
// class Resource {
// public:
//     Resource() { cout << "Resource created\n"; }
//     ~Resource() { cout << "Resource destroyed\n"; }
//     void use() { cout << "Using resource\n"; }
// };
// void uniquePtrScenarios() {
//     // 场景1：函数内局部资源管理
//     unique_ptr<Resource> localResource = make_unique<Resource>();
//     localResource->use();
//     // 场景2：作为函数参数（转移所有权）
//     auto createResource = []() -> unique_ptr<Resource> {
//         return make_unique<Resource>();
//     };
//     unique_ptr<Resource> resource = createResource();
//     // 场景3：类成员资源（独占所有权）
//     class Owner {
//         unique_ptr<Resource> resource;
//     public:
//         Owner() : resource(make_unique<Resource>()) {}
//     };
//     Owner owner;
// }
// int main()
// {
//     uniquePtrScenarios();
//     return 0;
// }

// //拷贝
// #include <iostream>
// using namespace std;
// void shallowCopyExample() {
//     int* original = new int(42);
//     int* copy = original;  // 浅拷贝：只复制指针地址
//     cout << "Original: " << *original << " at " << original << endl;
//     cout << "Copy: " << *copy << " at " << copy << endl;
//     // 修改copy会影响original
//     *copy = 100;
//     cout << "After modification - Original: " << *original << endl;  // 输出: 100
//     // 危险：双重释放！
//     // delete original;
//     // delete copy;  // 错误：同一内存被释放两次
// }
// void deepCopyExample() {
//     int* original = new int(42);
//     int* copy = new int(*original);  // 深拷贝：复制数据内容
//     cout << "Original: " << *original << " at " << original << endl;
//     cout << "Copy: " << *copy << " at " << copy << endl;
//     // 修改copy不会影响original
//     *copy = 100;
//     cout << "After modification - Original: " << *original << endl;  // 输出: 42
//     // 安全：各自释放
//     delete original;
//     delete copy;
// }
// int main()
// {
//     shallowCopyExample();
//     deepCopyExample();
//     return 0;
// }

// //c++的三大特性，封装、继承、多态
// #include <iostream>
// using namespace std;
// class People{
//  private:
//  string name;
//  int age;
//  public:
//  People(string n ,int a){
//     this->name=n;
//     this->age=a;
//     cout << "People对象被创建: " << n << endl;
//  }
// string Getname()
// {
//     return name;
// }
// int Getage()
// {
//     return age;
// }
// virtual  int VirtuGetage()
// {
// return age;
// }
//     virtual ~People() {} // 虚析构函数：确保正确释放派生类对象
// };
// class Student: public People
// {
// public:
//  Student (string n1,int a1):People(n1,a1){};
// int  VirtuGetage() override
// {
//     return 1+People::VirtuGetage();
// }
// };
// int main()
// {
//     People p("张三",18);
//     cout<<"姓名："<<p.Getname()<<endl;
//     // 通过公共接口访问私有属性 - 封装的体现
//     // 封装：将对象属性使用private保护起来，向外部提供功能接口，只能通过对象访问
// Student s("李四",15);
// cout<<"姓名："<<s.Getname()<<endl;
// cout<<"年龄："<<s.VirtuGetage()<<endl;
// People* psr=&s;// 基类指针指向派生类对象
// cout<<"年龄"<<psr->VirtuGetage()<<endl;
//     return 0;
// }

// //模版
// #include <iostream>
// using namespace std;
// template <typename T>
// T getMax(T a,T b)
// {
//     return (a>b)? a:b;
// }
// int main()
// {
// //这样就不用定义数据类型了,但要保证传入的两个数据类型相同
// cout<<getMax(1,100)<<endl;
// cout<<getMax("abc","sji")<<endl;
// }

// //容器算法
// //查找算法
// #include<iostream>
// #include<algorithm>
// #include<vector>
// using namespace std;
// bool customCompare(int a,int b)
// {
//     return a<b;
// }
// int main()
// {
// vector<int> v={1,8,5,3,6,4,5};
// for(int i:v)
// cout<<i<<" ";
// cout<<endl;
// sort(v.begin(),v.end(),customCompare);//排序算法
//  for(int i:v)
// cout<<i<<" ";
// int target1=8;
// auto it=find(v.begin(),v.end(),target1);//注意返回的是迭代器
// if(it!=v.end())
// {
//     cout<<endl<<"找到"<<*it<<"位置："<<distance(v.begin(),it)<<endl;//
// }
// else
// {
//     cout<<*it<<"不再数组中"<<endl;
// }
// int target2=6;
// bool found=binary_search(v.begin(),v.end(),target2);//他只能判断target是否存在
// if(found==true)
// {
//     cout<<"找到了"<<target2<<endl;
// }
// else
// {
//     cout<<"没找到了"<<target2<<endl;
// }
// int target3=5;
// auto it1=lower_bound(v.begin(),v.end(),target3);//返回第一个不小于（可能等于）目标值的元素的迭代器
// if(it1!=v.end())
// {
//     cout<<endl<<"找到"<<*it1<<"位置："<<distance(v.begin(),it1)<<endl;//
// }
// else
// {
//     cout<<*it1<<"不再数组中"<<endl;
// }
// int target4=4;
// auto it2=upper_bound(v.begin(),v.end(),target4);//返回第一个大于目标值的元素的迭代器
// if(it2!=v.end())
// {
// cout<<"找到第一个大于："<<target4<<"的值，位置为"<<distance(v.begin(),it2)<<endl;
// }
// else
// {
// cout<<"没有大于"<<target4<<"的值"<<endl;
// }
// int target5=5;
// auto  range=equal_range(v.begin(),v.end(),target5);//返回first（第一个等于目标值的索引位），second(第一个大于目标值的元素的索引位)所以在表示范围时要减一
// if(range.first!=range.second)
// {
//     cout << "找到 " << target5  << "位置在索引 " << distance(v.begin(), range.first) << endl;
//     cout<<"索引范围："<<distance(v.begin(),range.first)<<"到"<<distance(v.begin(),range.second-1)<<endl;//second 指向的是第一个大于目标值的元素
// }
// else
// {
// cout<<"没找到"<<endl;
// }
// auto it3=find_if(v.begin(),v.end(),[] (int x){return x%4==0;});// 查找第一个能被4整除的数
// if(it3!=v.end())
// {
//     cout<<"找到了第一个能被4整除的数："<<*it<<"  位置："<<distance(v.begin(),it);
// }
// return 0;
// }
//
#include <iostream>
#include <vector>
using namespace std;
void insertionSort(vector<int> &arr)
{
    int n = arr.size();
    for (int i = 1; i < n; i++)
    {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key)
        {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}
void Print(vector<int> &arr)
{
    int num = arr.size();
    for (int i = 0; i < num; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
}
int main()
{
    vector<int> arr = {25, 36, 5, 4, 58, 99, 88, 56, 15};
    Print(arr);
    insertionSort(arr);
     Print(arr);

    return 0;
}
